// TIP : 使用浏览器测试JS引用数据时，通过 log 方式输出的结果时具有延迟操作的
//       对与引用数据而言，通过 log 方式测试结果并不准确
//          为保证真实测试的准确性
//              方式1 debug
//              方式2 table 进行引用数据结果展示（对内容少量的数据可以）

// push()	将新元素添加到数组的末尾，并返回新的长度。 ==> 改变原数组
let arr1 = [];
// console.log(arr1);
console.table(arr1);
console.log( arr1.push(100) );
console.log( arr1.push(101) );
console.log( arr1.push(102,103,104,105) );
// for (let i = 0; i < 100; i++) {
//     arr1.push(i)
// }
// debugger; // 在17代码位置开启debugger测试功能
// console.log(arr1);
console.table(arr1);
// pop()	删除数组的最后一个元素，并返回该元素。 ==> 改变原数组
console.log( arr1.pop() )
console.log( arr1.pop() )
console.table(arr1)

// unshift()	将新元素添加到数组的开头，并返回新的长度。 方法的操作对原数组的元素下标会产生影响
//                      ==> 改变原数组
// shift()	删除数组的第一个元素，并返回该元素。 方法的操作对原数组的元素下标会产生影响
//                      ==> 改变原数组
console.log( arr1.unshift(200) )
console.log( arr1.unshift(201,202) )
console.table(arr1)
console.log( arr1.shift() )
console.log( arr1.shift() )
console.table(arr1)

// fill()	用静态值填充数组中的元素。 ==> 改变原数组
let arr2 = new Array(); // length 为 0 不可以循环
let arr3 = []; // length 为 0 不可以循环
let arr4 = new Array(10); // length 为 10 可以循环
console.log( arr2 )
console.log( arr3 )
console.log( arr4 )
// 数组的长度通过 length属性 可以获取
for (let i = 0; i < arr4.length; i++) {
    console.log("arr",arr4[i])
}
// arr4.fill("default"); // 从 0 填充到 length-1
arr4.fill("default",2,6); // 从 0 填充到 length-1
console.table(arr4)

// copyWithin(target,start,end)	将数组中的数组元素复制到指定位置或从指定位置复制。
//      + target 复制元素填充的起始下标
//      + [start,end] 设置从第几个元素复制到第几个元素
//          ==> 改变原数组
let arr5 = new Array(10);
arr5[0] = "A";
arr5[1] = "B";
arr5[2] = "C";
console.table(arr5)
arr5 = arr5.copyWithin(3,0,3)
console.table(arr5)

// length  数组长度属性 - 取值获取数组的当前长度，赋值会改变当前数组的长度
let arr6 = [1,2,3,4];
console.log( arr6.length )
arr6.length = 2;
console.table(arr6)
arr6.length = 0;
console.log( arr6 )

// Array.isArray( 变量 )	检查对象是否为数组。  ==> 不改变原数组
let arr7 = [];
console.log( typeof arr7 )
console.log( Array.isArray( arr7 ) )

// concat(...item)	连接两个或多个数组，并返回已连接数组的副本。 ==> 不改变原数组
let arr81 = [100,200,300];
let arr82 = ["aaa","bb","cc"];
// let arr8 = arr81.concat( arr82 );
let arr8 = arr81.concat( arr82,[true,false] );
console.table(arr8)

// forEach( callback(item,index,arr) )	为每个数组元素调用函数。 ==> 不改变原数组
let arr9 = [11,22,33,44,55,66,33,77];
for (let i = 0; i <arr9.length; i++) {
    console.log(`arr9[${i}]:${arr9[i]}`)
}
console.log("=============")
for (let i in arr9) {
    console.log(`arr9[${i}]:${arr9[i]}`)
}
console.log("=============")
for (let v of arr9) {
    console.log(`arr9:${v}`)
}
arr9.forEach( function (item,index,array){
    console.log(`数组:${array},当前循环到第${index}下标元素，元素值${item}`)
} )

// includes()	检查数组是否包含指定的元素。 ==> 不改变原数组
console.log( arr9.includes(33) )
console.log( arr9.includes(33,4) )
// indexOf()	在数组中搜索元素并返回其位置。==> 不改变原数组
console.log( arr9.indexOf(33) )
console.log( arr9.indexOf(999) )
// lastIndexOf()	在数组中搜索元素，从末尾开始，并返回其位置。==> 不改变原数组
console.log( arr9.lastIndexOf(33) )
console.log( arr9.lastIndexOf(999) )

// slice(start,end)	选择数组的一部分，并返回新数组。 ==> 不改变原数组
//          start 起始下标  end 结束下标  [start,end)
let arr10 = [100,200,300,400,500,600];
let arr11 = arr10.slice(2,4);
console.log("arr10",arr10);
console.log("arr11",arr11);
// splice(start,deleteCount)	从数组中删除元素，并将删除的元素添加到新数组中。 ==> 改变原数组
//          从 start 指定的下标位置向后删除 deleteCount 数量的元素
let arr12 = [100,200,300,400,500,600];
let arr13 = arr12.splice(2,3)
console.log("arr12",arr12)
console.log("arr13",arr13)

// toString()	将数组转换为字符串，并返回结果。（以,将数组元素连接成一个字符串）
let arr14 = ["aa",100,true,new Date()];
console.log( arr14.toString() )
console.log( "["+arr14+"]" ) // 默认调用toString
// join(spe)	将数组的所有元素连接成一个字符串。
console.log( arr14.join("-") )
console.log( arr14.join(",") ) // 等同与 toString

// 数组中存在隐式循环的执行方法
// find( callback(item,index,arr) )	返回数组中第一个通过测试的元素的值。
// findIndex( callback(item,index,arr) )	返回数组中通过测试的第一个元素的索引。
let arr15 = [15,18,23,22,24,13];
// let num1 = null;
// for (let i = 0; i < arr15.length; i++) {
//     if(arr15[i]>20){
//         num1 = arr15[i];
//         break;
//     }
// }
// 上述操作等同如下
// let num1 = arr15.find( function (v,i,arr){
// //    返回true表示符合条件，返回false表示不符合条件
//     return v > 20;
// } )
// 简化
let num1 = arr15.find( v => v>20 );

// let index1 = arr15.findIndex( function (v,i,arr){
// //    返回true表示符合条件，返回false表示不符合条件
//     return v > 20;
// } )
// 简化
let index1 = arr15.findIndex( v=>v>20 );
console.log(index1,num1)

// every( callback(v,i,arr) )	检查数组中的每个元素是否通过测试。
let arr16 = [15,18,23,22,24,13];
// let flag1 = arr16.every( function (v,i){
// //    返回true表示符合条件 ，返回false表示不符合条件
//     return v < 30
// } )
let flag1 = arr16.every( v=>v<30 );
console.log( flag1 )
// 当数组为空时，始终返回true
console.log( [].every( v=>v>30 ) );

// some()	检查数组中的任何元素是否通过测试。
let flag2 = arr16.some( (v,i)=>{
// 返回true表示符合条件 ，返回false表示不符合条件
    return v > 20
} );
console.log( flag2 )

// filter()	使用数组中通过测试的每个元素创建新数组。
let tempArr1 = arr16.filter( (v,i)=>{
// 返回true表示符合条件 ，返回false表示不符合条件
    return v%2==0;
} )
console.log( tempArr1 )

// map()	使用为每个数组元素调用函数的结果创建新数组。
let tempArr2 = arr16.map( (v,i)=>{
    return `<li>年龄:${v}</li>`
} )
console.table( tempArr2 )
// console.table( tempArr2.join("") )

// reduce( callback(preValue,currentValue,currentIndex,arr),startValue )
// 将数组的值减为单个值（从左到右）。
// reduceRight()	将数组的值减为单个值（从右到左）。
let arr17 = [1,2,3,4,5];
let sum1 = arr17.reduce( (pv,v,i)=>{
    console.log( `pv:${pv};v:${v};i:${i}` );
    return pv+v;
} , 0 )
console.log( sum1 );

// reverse()	反转数组中元素的顺序。
let arr18 = arr17.reverse();
console.log(arr18)

// 冒泡排序
let numArrs = [ 88, 25, 9, 44, 80, 63, 49, 83, 19, 55, 39, 74 ];
// for (let i = 0; i < numArrs.length - 1; i++) {
//     for (let j = i + 1; j < numArrs.length; j++) {
//         if(numArrs[i]>numArrs[j]){
//             let temp = numArrs[i];
//             numArrs[i] = numArrs[j];
//             numArrs[j] = temp;
//         }
//     }
// }
for (let i = 0; i < numArrs.length - 1; i++) {
    for (let j = 0; j < numArrs.length - 1; j++) {
        if( numArrs[j]>numArrs[j+1] ){
            let temp = numArrs[j+1];
            numArrs[j+1] = numArrs[j];
            numArrs[j] = temp;
        }
    }
}
console.table( numArrs )

// sort(currentValue,nextValue)	对数组的元素进行排序。 ==> 修改原数组
//                             ==> 默认排序规则基于位置参考ASSII进行排序
let numArrs2 = [ 88, 25, 9, 44, 80, 63, 49, 83, 19, 55, 39, 74 ];
// numArrs2.sort();  // 默认依据assii码排序
// numArrs2.sort( (currentValue,nextValue)=>{
// //   在 currentValue - nextValue
// //          返回 > 0 值表示  currentValue 大于 nextValue 【升序】
// //          返回 < 0 值表示 currentValue 小于 nextValue 【降序】
// //     return currentValue - nextValue // 升序
//     return nextValue - currentValue // 降序
// } )
numArrs2.sort( (cv,nv)=>cv-nv );
console.table( numArrs2 )








